 import { validatenull } from './validate'
//表单序列化
export const serialize = data => {
    let list = [];
    Object.keys(data).forEach(ele => {
        list.push(`${ele}=${data[ele]}`)
    })
    return list.join('&');
};
export const getObjType = obj => {
    var toString = Object.prototype.toString;
    var map = {
        '[object Boolean]': 'boolean',
        '[object Number]': 'number',
        '[object String]': 'string',
        '[object Function]': 'function',
        '[object Array]': 'array',
        '[object Date]': 'date',
        '[object RegExp]': 'regExp',
        '[object Undefined]': 'undefined',
        '[object Null]': 'null',
        '[object Object]': 'object'
    };
    if (obj instanceof Element) {
        return 'element';
    }
    return map[toString.call(obj)];
};
export const getViewDom = () => {
    return window.document.getElementById('avue-view').getElementsByClassName('el-scrollbar__wrap')[0]
}
/**
 * 对象深拷贝
 */
export const deepClone = data => {
    var type = getObjType(data);
    var obj;
    if (type === 'array') {
        obj = [];
    } else if (type === 'object') {
        obj = {};
    } else {
        //不再具有下一层次
        return data;
    }
    if (type === 'array') {
        for (var i = 0, len = data.length; i < len; i++) {
            obj.push(deepClone(data[i]));
        }
    } else if (type === 'object') {
        for (var key in data) {
            obj[key] = deepClone(data[key]);
        }
    }
    return obj;
};
/**
 * 设置灰度模式
 */
export const toggleGrayMode = (status) => {
    if (status) {
        document.body.className = document.body.className + ' grayMode';
    } else {
        document.body.className = document.body.className.replace(' grayMode', '');
    }
};
/**
 * 设置主题
 */
export const setTheme = (name) => {
    document.body.className = name;
}

/**
 * 加密处理
 */
export const encryption = (params) => {
    let {
        data,
        type,
        param,
        key
    } = params;
    let result = JSON.parse(JSON.stringify(data));
    if (type == 'Base64') {
        param.forEach(ele => {
            result[ele] = btoa(result[ele]);
        })
    } else if (type == 'Aes') {
        param.forEach(ele => {
            result[ele] = window.CryptoJS.AES.encrypt(result[ele], key).toString();
        })

    }
    return result;
};


/**
 * 浏览器判断是否全屏
 */
export const fullscreenToggel = () => {
    if (fullscreenEnable()) {
        exitFullScreen();
    } else {
        reqFullScreen();
    }
};
/**
 * esc监听全屏
 */
export const listenfullscreen = (callback) => {
    function listen() {
        callback()
    }
    document.addEventListener("fullscreenchange", function () {
        listen();
    });
    document.addEventListener("mozfullscreenchange", function () {
        listen();
    });
    document.addEventListener("webkitfullscreenchange", function () {
        listen();
    });
    document.addEventListener("msfullscreenchange", function () {
        listen();
    });
};
/**
 * 浏览器判断是否全屏
 */
export const fullscreenEnable = () => {
    var isFullscreen = document.isFullScreen || document.mozIsFullScreen || document.webkitIsFullScreen
    return isFullscreen;
}

/**
 * 浏览器全屏
 */
export const reqFullScreen = () => {
    if (document.documentElement.requestFullScreen) {
        document.documentElement.requestFullScreen();
    } else if (document.documentElement.webkitRequestFullScreen) {
        document.documentElement.webkitRequestFullScreen();
    } else if (document.documentElement.mozRequestFullScreen) {
        document.documentElement.mozRequestFullScreen();
    }
};
/**
 * 浏览器退出全屏
 */
export const exitFullScreen = () => {
    if (document.documentElement.requestFullScreen) {
        document.exitFullScreen();
    } else if (document.documentElement.webkitRequestFullScreen) {
        document.webkitCancelFullScreen();
    } else if (document.documentElement.mozRequestFullScreen) {
        document.mozCancelFullScreen();
    }
};
/**
 * 递归寻找子类的父类
 */

export const findParent = (menu, id) => {
    for (let i = 0; i < menu.length; i++) {
        if (menu[i].children.length != 0) {
            for (let j = 0; j < menu[i].children.length; j++) {
                if (menu[i].children[j].id == id) {
                    return menu[i];
                } else {
                    if (menu[i].children[j].children.length != 0) {
                        return findParent(menu[i].children[j].children, id);
                    }
                }
            }
        }
    }
};
/**
 * 判断2个对象属性和值是否相等
 */

/**
 * 动态插入css
 */

export const loadStyle = url => {
    const link = document.createElement('link');
    link.type = 'text/css';
    link.rel = 'stylesheet';
    link.href = url;
    const head = document.getElementsByTagName('head')[0];
    head.appendChild(link);
};
/**
 * 判断路由是否相等
 */
export const diff = (obj1, obj2) => {
    delete obj1.close;
    var o1 = obj1 instanceof Object;
    var o2 = obj2 instanceof Object;
    if (!o1 || !o2) { /*  判断不是对象  */
        return obj1 === obj2;
    }

    if (Object.keys(obj1).length !== Object.keys(obj2).length) {
        return false;
        //Object.keys() 返回一个由对象的自身可枚举属性(key值)组成的数组,例如：数组返回下表：let arr = ["a", "b", "c"];console.log(Object.keys(arr))->0,1,2;
    }

    for (var attr in obj1) {
        var t1 = obj1[attr] instanceof Object;
        var t2 = obj2[attr] instanceof Object;
        if (t1 && t2) {
            return diff(obj1[attr], obj2[attr]);
        } else if (obj1[attr] !== obj2[attr]) {
            return false;
        }
    }
    return true;
}
/**
 * 根据字典的value显示label
 */
export const findByvalue = (dic, value) => {
    let result = '';
    if (validatenull(dic)) return value;
    if (typeof (value) == 'string' || typeof (value) == 'number' || typeof (value) == 'boolean') {
        let index = 0;
        index = findArray(dic, value);
        if (index != -1) {
            result = dic[index].label;
        } else {
            result = value;
        }
    } else if (value instanceof Array) {
        result = [];
        let index = 0;
        value.forEach(ele => {
            index = findArray(dic, ele);
            if (index != -1) {
                result.push(dic[index].label);
            } else {
                result.push(value);
            }
        });
        result = result.toString();
    }
    return result;
};
/**
 * 根据字典的value查找对应的index
 */
export const findArray = (dic, value) => {
    for (let i = 0; i < dic.length; i++) {
        if (dic[i].value == value) {
            return i;
        }
    }
    return -1;
};
/**
 * 生成随机len位数字
 */
export const randomLenNum = (len, date) => {
    let random = '';
    random = Math.ceil(Math.random() * 100000000000000).toString().substr(0, len ? len : 4);
    if (date) random = random + Date.now();
    return random;
};
/**
 * 打开小窗口
 */
export const openWindow = (url, title, w, h) => {
    // Fixes dual-screen position                            Most browsers       Firefox
    const dualScreenLeft = window.screenLeft !== undefined ? window.screenLeft : screen.left
    const dualScreenTop = window.screenTop !== undefined ? window.screenTop : screen.top

    const width = window.innerWidth ? window.innerWidth : document.documentElement.clientWidth ? document.documentElement.clientWidth : screen.width
    const height = window.innerHeight ? window.innerHeight : document.documentElement.clientHeight ? document.documentElement.clientHeight : screen.height

    const left = ((width / 2) - (w / 2)) + dualScreenLeft
    const top = ((height / 2) - (h / 2)) + dualScreenTop
    const newWindow = window.open(url, title, 'toolbar=no, location=no, directories=no, status=no, menubar=no, scrollbars=no, resizable=yes, copyhistory=no, width=' + w + ', height=' + h + ', top=' + top + ', left=' + left)

    // Puts focus on the newWindow
    if (window.focus) {
        newWindow.focus()
    }
}

/**
 * 转换文件格式 B/KB/MB/GB
 * @param limit
 * @returns {string}
 */
export const convertFileSize = (limit) => {
    var size = "";
    if( limit < 0.1 * 1024 ){ //如果小于0.1KB转化成B
        size = limit.toFixed(2) + "B";
    }else if(limit < 0.1 * 1024 * 1024 ){//如果小于0.1MB转化成KB
        size = (limit / 1024).toFixed(2) + "KB";
    }else if(limit < 0.1 * 1024 * 1024 * 1024){ //如果小于0.1GB转化成MB
        size = (limit / (1024 * 1024)).toFixed(2) + "MB";
    }else{ //其他转化成GB
        size = (limit / (1024 * 1024 * 1024)).toFixed(2) + "GB";
    }

    var sizestr = size + "";
    var len = sizestr.indexOf(".");
    var dec = sizestr.substr(len + 1, 2);
    if(dec == "00"){//当小数点后为00时 去掉小数部分
        return sizestr.substring(0,len) + sizestr.substr(len + 3,2);
    }
    return sizestr;
}

// 验证是否为大于等于0的整数
export function isInteger(rule, value, callback) {
    if(value!=0){
        if (!value) {
            return callback(new Error('输入不可以为空'));
        }
    }

    setTimeout(() => {
        if(value==0){
            callback();
        }
        else{
            if (!Number(value)) {
                callback(new Error('请输入大于等于0的整数'));
            } else {
                const re = /^[0-9]*[1-9][0-9]*$/;
                const rsCheck = re.test(value);
                if (!rsCheck) {
                    callback(new Error('请输入大于等于0的整数'));
                } else {
                    callback();
                }
            }
        }

    }, 0);
}
// 验证是否为大于等于0的数,保留两位小数
export function isIntegerFixTwo(rule, value, callback) {
    if(value!=0){
        if (!value) {
            return callback(new Error('输入不可以为空'));
        }
    }

    setTimeout(() => {
        if(value==0){
            callback();
        }
        else{
            if (!Number(value)) {
                callback(new Error('请输入大于等于0的数（保留两位小数）'));
            } else {
                const re = /^(0|[1-9][0-9]{0,9})(\.[0-9]{1,2})?$/
                const rsCheck = re.test(value);
                if (!rsCheck) {
					if(value>99999999.99) {
						callback(new Error('最大值不超过99999999.99'));
					}else{
						callback(new Error('请输入大于等于0的数（保留两位小数）'));
					}
                }  else {
                    callback();
                }
            }
        }

    }, 0);
}
// 验证是否为大于0的整数
export function isInteger0(rule, value, callback) {
	if (!value) {
		return callback(new Error('请输入大于0的整数'));
	}

    setTimeout(() => {
		if (!Number(value)) {
			callback(new Error('请输入大于0的整数'));
		} else {
			
			const re = /^\+?[1-9][0-9]*$/;
			const rsCheck = re.test(value);
			if (!rsCheck) {
				callback(new Error('请输入大于0的整数'));
			} else if(value>2147483648){
				callback(new Error('输入整数不能大于2147483648'));
			} else {
				callback();
			}
		}

    }, 0);
}
 //特殊字符判断
 export function validateFormat(rule,value,callback) {
    if(!value){
        return callback(new Error('请输入内容'))
    }
     setTimeout(() => {
             const re = /^[\u4E00-\u9FA5A-Za-z0-9_]+$/;
             const rsCheck = re.test(value);
             if (!rsCheck) {
                 callback(new Error('只能输入汉字、字母、数字和下划线的组合'));
             }else {
                 callback();
             }
     }, 0);
 }
 //特殊字符判断
 export function validateServiceName(rule,value,callback) {
     if(!value){
         return callback(new Error('请输入内容'))
     }
     setTimeout(() => {
         const re = /^[\u4E00-\u9FA5A-Za-z0-9_、]+$/;
         const rsCheck = re.test(value);
         if (!rsCheck) {
             callback(new Error('只能输入汉字、字母、数字、顿号（、）和下划线的组合'));
         }else {
             callback();
         }
     }, 0);
 }
 export function validateFormatLine(rule,value,callback) {
     if(!value){
         return callback(new Error('请输入内容'))
     }
     setTimeout(() => {
         const re = /^[\u4E00-\u9FA5A-Za-z0-9_\/\\]+$/;
         const rsCheck = re.test(value);
         if (!rsCheck) {
             callback(new Error('只能输入汉字、字母、数字、斜线和下划线的组合'));
         }else {
             callback();
         }
     }, 0);
 }
 //验证是否只包含 数字,字母
 export function validateNumEnglish(rule,value,callback) {
     if(!value){
         return callback(new Error('请输入内容'))
     }
     setTimeout(() => {
         const re = /^[A-Za-z0-9]+$/;
         const rsCheck = re.test(value);
         if (!rsCheck) {
             callback(new Error('只能输入数字、字母的组合'));
         }else {
             callback();
         }
     }, 0);
 }
 //统一信用代码
 // 统一代码为18位，统一代码由十八位的数字或大写英文字母（不适用I、O、Z、S、V）组成，由五个部分组成：
 // 第一部分（第1位）为登记管理部门代码，9表示工商部门；(数字或大写英文字母)
 // 第二部分（第2位）为机构类别代码;(数字或大写英文字母)
 // 第三部分（第3-8位）为登记管理机关行政区划码；(数字)
 // 第四部分（第9-17位）为全国组织机构代码；(数字或大写英文字母)
 // 第五部分（第18位）为校验码(数字或大写英文字母)
 // 企业注册号的正则,它的规则是15位数字字母组成
 export function validateCreditCode(rule,value,callback) {
     if(!value){
         return callback(new Error('请输入内容'))
     }
     setTimeout(() => {
         const re18 = /^[^_IOZSVa-z\W]{2}\d{6}[^_IOZSVa-z\W]{10}$/g;
         const re15 = /^[A-Za-z0-9]\w{14}$/g;
         if (value.length==18) {
			if(!re18.test(value)){
				callback(new Error('请输入正确的统一信用代码'));
			}else{
				callback();
			}
            
         }else if(value.length==15){
            if(!re15.test(value)){
            	callback(new Error('请输入正确的统一信用代码'));
            }else{
            	callback();
            }
         }else{
			callback(new Error('请输入正确的统一信用代码'));
		 }
     }, 0);
 }
 //验证是否只包含 汉字,字母
 export function validateChineseEnglish(rule,value,callback) {
     if(!value){
         return callback()
     }
     setTimeout(() => {
         const re = /^[\u4E00-\u9FA5A-Za-z]+$/;
         const rsCheck = re.test(value);
         if (!rsCheck) {
             callback(new Error('只能输入汉字、字母的组合'));
         }else {
             callback();
         }
     }, 0);
 }
 //验证是否只包含 数字
 export function validateNum(rule,value,callback) {
     if(!value){
         return callback(new Error('请输入内容'))
     }
     setTimeout(() => {
         const re = /^[0-9]+$/;
         const rsCheck = re.test(value);
         if (!rsCheck) {
             callback(new Error('只能输入数字'));
         }else {
             callback();
         }
     }, 0);
 }
 //除了%&+之外
 export function validateSpecial(rule,value,callback) {
     if(!value){
         return callback(new Error('请输入内容'))
     }
     setTimeout(() => {
         const re = /^[%+&]+$/;
         const rsCheck = re.test(value);
         if (rsCheck) {
             callback(new Error('不能输入%/&/+'));
         }else {
             callback();
         }
     }, 0);
 }

// 验证所输入是否为
export function isTestPwd(rule, value, callback) {
    if (!value) {
        return callback(new Error('输入不可以为空'));
    }
    setTimeout(() => {
        if(value==0){
            callback();
        }
        else{
            if (!Number(value)) {
                callback(new Error('请输入大于等于0的整数'));
            } else {
                const re = /^[0-9]*[1-9][0-9]*$/;
                const rsCheck = re.test(value);
                if (!rsCheck) {
                    callback(new Error('请输入大于等于0的整数'));
                } else {
                   let _pwd = value + "";
                   if(_pwd.length!=6){
                       callback(new Error('所输入内容不符合6位整数的规则'));
                   }
                   else{
                       callback();
                   }
                }
            }
        }

    }, 0);
}

 // 检查长度是否在2-10之间
export function testLength(rule, value, callback) {
    if (!value) {
        return callback(new Error('输入不可以为空'));
    }
    setTimeout(() => {

            if (value.length<2 || value.length>10) {
                callback(new Error('请输入2-10位字符'));
            } else {
                callback();
            }

    }, 0);
}
// 检查长度是否在4-20之间的快递公司代码
export function testExpressCode(rule, value, callback) {
    if (!value) {
        return callback(new Error('输入不可以为空'));
    }
    setTimeout(() => {
			let reg  = /^([0-9A-Za-z])+$/
            if (!reg.test(value)) {
                callback(new Error('请输入英文或者数字'));
            } else {
                callback();
            }

    }, 0);
}

// 检查文章来源和链接长度
export function testUrlSourceLength(rule, value, callback) {

    setTimeout(() => {

        if (value.length>40) {
            callback(new Error('请输入40位以内字符'));
        } else {
            callback();
        }

    }, 0);
}

export function isTestPwda(rule, value, callback) {
    if (!value) {
        return callback(new Error('输入不可以为空'));
    }
    setTimeout(() => {
        if(value==0){
            callback();
        }
        else{
            if (!Number(value)) {
                callback(new Error('请输入大于等于0的整数'));
            } else {
                let newValue= value.replace(/\s*/g,"");
                const re = /^[0-9]*[1-9][0-9]*$/;
                const rsCheck = re.test(newValue);
                if (!rsCheck) {
                    callback(new Error('请输入大于等于0的整数'));
                } else {
                    let _pwd = value + "";
                    if(_pwd.length!=6){
                        callback(new Error('所输入内容不符合6位整数的规则'));
                    }
                    else{
                        callback();
                    }
                }
            }
        }

    }, 0);
}


//验证价格0.01-99999999.99
export function testPirce(rule, value, callback) {
    if(value!=0){
        if (!value) {
            callback(new Error('输入不可以为空'));
        }
    }else if(value==0){
        callback(new Error('价格必须是0.01-99999999.99之间的数字(保留两位小数)'));
    }
    setTimeout(() => {
        if (!Number(value)) {
            callback(new Error('价格必须是0.01-99999999.99之间的数字(保留两位小数)'));
        } else {
            const re = /^(0|[1-9][0-9]{0,9})(\.[0-9]{1,2})?$/;
            const rsCheck = re.test(value);
            if (!rsCheck) {
				if(value>99999999.99 ){
				    callback(new Error('价格必须是0.01-99999999.99之间的数字(保留两位小数)'));
				}else{
					callback(new Error('价格必须是0.01-99999999.99之间的数字(保留两位小数)'));
				}
            } else {
                    if(value<0.01 || value>99999999.99 ){
                        callback(new Error('价格必须是0.01-99999999.99之间的数字(保留两位小数)'));
                    }
                    else{
                        callback();
                    }
                }
        }
    }, 0);
}



 //验证输入的打款金额
 export function testActualAmount(rule, value, callback) {
     if(value!=0){
         if (!value) {
             callback(new Error('输入不可以为空'));
         }
     }else if(value==0){
         callback(new Error('金额必须是0.01-99999999.99之间的数字(保留两位小数)'));
     }
     setTimeout(() => {
         if (!Number(value)) {
             callback(new Error('金额必须是0.01-99999999.99之间的数字(保留两位小数)'));
         } else {
             const re = /^(0|[1-9][0-9]{0,9})(\.[0-9]{1,2})?$/;
             const rsCheck = re.test(value);
             if (!rsCheck) {
                 if(value>99999999.99 ){
                     callback(new Error('金额必须是0.01-99999999.99之间的数字(保留两位小数)'));
                 }else{
                     callback(new Error('金额必须是0.01-99999999.99之间的数字(保留两位小数)'));
                 }
             } else {
                 if(value<0.01 || value>99999999.99 ){
                     callback(new Error('金额必须是0.01-99999999.99之间的数字(保留两位小数)'));
                 }
                 else{
                     callback();
                 }
             }
         }
     }, 0);
 }


 //验证价格0.01-10000.00
 export function testPirceTenThousand(rule, value, callback) {
     if(value!=0){
         if (!value) {
             callback(new Error('输入不可以为空'));
         }
     }else if(value==0){
         callback(new Error('价格必须是0.01-10000.00之间的数字(保留两位小数)'));
     }
     setTimeout(() => {
         if (!Number(value)) {
             callback(new Error('价格必须是0.01-10000.00之间的数字(保留两位小数)'));
         } else {
             const re = /^(0|[1-9][0-9]{0,9})(\.[0-9]{1,2})?$/;
             const rsCheck = re.test(value);
             if (!rsCheck) {
                 if(value>10000 ){
                     callback(new Error('价格必须是0.01-10000.00之间的数字(保留两位小数)'));
                 }else{
                     callback(new Error('价格必须是0.01-10000.00之间的数字(保留两位小数)'));
                 }
             } else {
                 if(value<0.01 || value>10000 ){
                     callback(new Error('价格必须是0.01-10000.00之间的数字(保留两位小数)'));
                 }
                 else{
                     callback();
                 }
             }
         }
     }, 0);
 }

//验证价格0-99999999.99
export function testPirceZero(rule, value, callback) {
    if(!value  && value!=0){
		callback(new Error('输入不可以为空'));
    }
    setTimeout(() => {
        // if (!Number(value)) {
        //     callback(new Error('价格必须是0-99999999.99之间的数字(保留两位小数)'));
        // } else {
			const re = /^\d{1,8}(\.\d{1,2})?$/
            const rsCheck = re.test(value);
			if(!rsCheck){
				if(value>99999999.99 ){
				    callback(new Error('价格必须是0-99999999.99之间的数字(保留两位小数)'));
				}else{
					callback(new Error('价格必须是0-99999999.99之间的数字(保留两位小数)'));
				}
			}else {
                    if(value<0 || value>99999999.99 ){
                        callback(new Error('价格必须是0-99999999.99之间的数字(保留两位小数)'));
                    }
                    else{
                        callback();
                    }
				}
    //         if (!rsCheck) {
				// if(value>99999999.99 ){
				//     callback(new Error('价格必须是0-99999999.99之间的数字(保留两位小数)'));
				// }else{
				// 	callback(new Error('价格必须是0-99999999.99之间的数字(保留两位小数)'));
				// }
    //         } else {
    //                 if(value<0 || value>99999999.99 ){
    //                     callback(new Error('价格必须是0-99999999.99之间的数字(保留两位小数)'));
    //                 }
    //                 else{
    //                     callback();
    //                 }
    //             }
        // }
    }, 0);
}

//验证运费模板安重量，体积计价时，重量，体积规则
export function testWeightAndVolue(rule, value, callback) {
    if(value==0){
        return callback(new Error('输入不可以为0或者为空'));
    }
    setTimeout(() => {
        if(value==0){
            callback();
        }
        else{
            if (!Number(value)) {
                callback(new Error('必须是数字'));
            } else {
                const re = /^(0|[1-9][0-9]{0,9})(\.[0-9]{1,2})?$/;
                const rsCheck = re.test(value);
                if(rsCheck){
                    if(value<0 || value>10000){
                        callback(new Error('数值介于0-10000之间（两位小数）'));
                    }
                }
                if (!rsCheck) {
                    callback(new Error('数值介于0-10000之间（两位小数）'));
                } else {
                    callback();
                }
            }
        }

    }, 0);
}

export function testGoodsWidth(rule, value, callback) {
    if (!value) {
        return callback(new Error('输入内容不可以为空或者为0'));
    }
    setTimeout(() => {
        if (!Number(value)) {
            callback(new Error('输入内容只能在0-1000之间(如果是小数，保留两位小数)'));
        } else {
            const re = /^(?!00)(?:[0-9]{1,3}|1000)$/;
            const rsCheck = re.test(value);
            if (!rsCheck) {
                callback(new Error('输入内容只能在0-1000之间(如果是小数，保留两位小数)'));
            } else {
                callback();
            }
        }
    }, 0);
}
//校验链接，不可以是汉字
export function testUrl(rule, value, callback) {
    setTimeout(() => {

            const re = /[\u4E00-\u9FA5]/g;
            const rsCheck = re.test(value);
            if (rsCheck) {
                callback(new Error('不可输入汉字'));
            } else {
                callback();
            }
    }, 0);
}
//区域名 必须为汉字 长度
export function testAreaName(rule, value, callback) {
    setTimeout(() => {

            const re = /[\u4E00-\u9FA5]/g;
            const rsCheck = re.test(value);
            if (!rsCheck) {
                callback(new Error('区域名必须为汉字'));
            } else if(value.length<2 ||value.length>12 ){
                callback(new Error('区域名为2-12个汉字'));
            }else {
                callback();
            }
    }, 0);
}

//校验邮编
export function validateZip(rule, value, callback) {
    setTimeout(() => {
		if (value === '') {
			callback(new Error('请输入邮政编码'))
		} else if (value.length != 6) {
			callback(new Error('邮政编码长度为6个字符'))
		} else if (!(/^[0-9]\d*$/).test(value)) {
			callback(new Error('邮政编码应为数字'))
		} else {
			callback();
		}
    }, 0);
}

//验证商品库存
export function testGoodsInventory(rule, value, callback) {
	value = value.trim();
	if (!value) {
		return callback(new Error('请输入0-1000000之间的整数'));
	}
	console.log(value)
    setTimeout(() => {
        if(value==0){
            callback();
        }
        else{
            if (!Number(value)) {
                callback(new Error('商品库存数量只能是0-1000000之间的整数'));
            } else {
                const re = /^[0-9]*$/;
                const rsCheck = re.test(value);
                if (!rsCheck) {
                    callback(new Error('商品库存数量只能是0-1000000之间的整数'));
                } else {
                    if(value<0 || value>1000000){
                        callback(new Error('商品库存数量只能是0-1000000之间的整数'));
                    }
                    else{
                        callback();
                    }
                }
            }
        }

    }, 0);
}

//验证积分价格
export function testIntegralPrice(rule, value, callback) {
    if(value!=0){
        if (!value) {
            return callback(new Error('输入不可以为空'));
        }
    }
    setTimeout(() => {
        if(value==0){
            callback();
        }
        else{
            if (!Number(value)) {
                callback(new Error('积分只能是0-99999999之间的整数'));
            } else {
                const re = /^[0-9]*$/;
                const rsCheck = re.test(value);
                if (!rsCheck) {
                    callback(new Error('积分只能是0-99999999之间的整数'));
                } else {
                    if(value<0 || value>99999999){
                        callback(new Error('积分只能是0-99999999之间的整数'));
                    }
                    else{
                        callback();
                    }
                }
            }
        }

    }, 0);
}

//验证商品权重
export function testGoodsSort(rule, value, callback) {
    let res=/^\+?[1-9][0-9]*$/
    if(!value){
        return callback(new Error('输入不可以为空'));
    }else if(!res.test(value)){
        return callback(new Error('值为大于0小于999的整数'));
    }else if(value<=0 || value>999){
        return callback(new Error('值要大于0小于999'));
    }else{
        callback();
    }
}

//验证商品编号
export function testGoodsSerial(rule, value, callback) {
	value = value.trim();
	if (!value) {
		return 
	}
    setTimeout(() => {
		let newValue= value.replace(/\s*/g,"");
		const re = /^[A-Za-z0-9]{5,16}$/;
		const rsCheck = re.test(newValue);
		if (!rsCheck) {
			callback(new Error('请输入5-15位数字或字母'));
		}else {
			callback();
		}
    }, 0);
}


//验证0-999999999
export function testSpaceSize(rule, value, callback) {
    if(value!=0){
        if (!value) {
            return callback(new Error('输入不可以为空'));
        }
    }
    setTimeout(() => {
        if(value==0){
            callback();
        }
        else{
            if (!Number(value)) {
                callback(new Error('所输入必须是数字'));
            } else {
                if(value<0 || value>999999999){
                    callback(new Error('所输入内容介于0-999999999'));
                }
                else{
                    callback();
                }
            }
        }

    }, 0);
}


//验证0.1-1（分佣比例）
export function testPercentageCommission(rule, value, callback) {
    if (!value) {
        return callback(new Error('输入不可以为空或者为0'));
    }
    setTimeout(() => {
        if (!Number(value)) {
            callback(new Error('所输入内容必须是0.01-1之间的数字'));
        } else {
            const re = /^(0|[1-9][0-9]{0,9})(\.[0-9]{1,2})?$/;
            const rsCheck = re.test(value);
            if (!rsCheck) {
                callback(new Error('所输入内容必须是0.01-1之间的数字'));
            } else {
                if(value<0.01 || value>1){
                    callback(new Error('所输入内容必须是0.01-1之间的数字'));
                }
                else{
                    callback();
                }
            }
        }

    }, 0);
}
//验证0-1（计提比例）
export function testExtractRate(rule, value, callback) {
    if (!value) {
        return callback(new Error('输入不可以为空或者为0'));
    }
    setTimeout(() => {
        if (!Number(value) && Number(value)!=0) {
            callback(new Error('所输入内容必须是0-1之间的数字'));
        } else {
            const re = /^(0|[1-9][0-9]{0,9})(\.[0-9]{1,2})?$/;
            const rsCheck = re.test(value);
            if (!rsCheck) {
                callback(new Error('所输入内容必须是0-1之间的数字'));
            } else {
                if(value<0 || value>1){
                    callback(new Error('所输入内容必须是0-1之间的数字'));
                }
                else{
                    callback();
                }
            }
        }

    }, 0);
}
//验证0.1-1（分佣比例）
export function testCommissionRate(rule, value, callback) {
    if (!value) {
        // return callback(new Error('输入不可以为空或者为0'));
        return callback();
    }
    setTimeout(() => {
        if (!Number(value)) {
            callback(new Error('所输入内容必须是0.01-1之间的数字'));
        } else {
            const re = /^(0|[1-9][0-9]{0,9})(\.[0-9]{1,2})?$/;
            const rsCheck = re.test(value);
            if (!rsCheck) {
                callback(new Error('所输入内容必须是0.01-1之间的数字'));
            } else {
                if(value<0.01 || value>1){
                    callback(new Error('所输入内容必须是0.01-1之间的数字'));
                }
                else{
                    callback();
                }
            }
        }

    }, 0);
}

//折扣为 1-99之间的正整数
export function testDisCount(rule, value, callback) {
    if (!value) {
        return callback(new Error('请输入折扣'));
    }
    setTimeout(() => {
        if (!Number(value)) {
            callback(new Error('折扣必须是1-99之间的正整数'));
        } else {
            const re = /^(0|[1-9][0-9]{0,9})(\.[0-9]{1,2})?$/;
            const rsCheck = re.test(value);
            if (!rsCheck) {
                callback(new Error('折扣必须是1-99之间的正整数'));
            } else {
                if( value>99){
                    callback(new Error('折扣必须是1-99之间的正整数'));
                }
                else{
                    callback();
                }
            }
        }

    }, 0);
}

//校验手机号
export function testPhone(rule, value, callback) {
    if (!value) {
        return callback(new Error('请输入正确的手机号'));
    }
    setTimeout(() => {
        if (!Number(value)) {
            callback(new Error('请输入正确的手机号'));
        } else {
            const re = /^1[3|4|5|7|8|9][0-9]{9}$/;
            const rsCheck = re.test(value);
            if (!rsCheck) {
                callback(new Error('请输入正确的手机号'));
            } else {
                callback();
            }
        }

    }, 0);
}


//校验日期
export function testBirthday(rule, value, callback) {
    if (!value) {
        return callback(new Error('请选日期'));
    }
    setTimeout(() => {
        let date = new Date(value.replace(/-/,"/"))
        //将时间转时间戳
        let birthday = date.getTime()
        let currentTimestamp = (new Date()).getTime();
        if(birthday > currentTimestamp){
            return callback(new Error('出生日期不能超过当前日期'));
        }
        else{
            callback();
        }

    }, 0);
}

//校验排序
export function testSort(rule, value, callback) {
    if(value!=0){
        if (!value) {
            return callback(new Error('输入不可以为空'));
        }
    }

    setTimeout(() => {
        if(value==0){
            callback(new Error('请输入大于0的整数'));
        }
        else{
            if (!Number(value)) {
                callback(new Error('请输入大于0的整数'));
            } else {
                const re = /^\+?[1-9][0-9]*$/;
                if (!re.test(value)) {
                    callback(new Error('请输入大于0的整数'));
                } else {
                    if(value>10000){
                        callback(new Error('所输入内容不能大于10000'));
                    }
                    else{
                        callback();
                    }
                }
            }
        }

    }, 0);
}


//校验用户密码
//规则:6-20为数字字母的组合，不包含特殊符号(可以是纯数字,可以是纯字母,可以是数字加字母)
// 这个规则也是可以的，跟下面一样的效果  /^(?![0-9]+$)(?![a-zA-Z]+$)[0-9A-Za-z]{6,20}$/
export function testPassWord(rule, value, callback) {
    if(value!=0){
        if (!value) {
            return callback(new Error('输入不可以为空'));
        }
    }
    setTimeout(() => {
        let newValue= value.replace(/\s*/g,"");
        const re = /(?!^\d+$)(?!^[A-Za-z]+$)(?!^_+$)^\w{6,16}$/;
        const test = re.test(newValue);
        if(test){
            callback();
        }
        else {
            callback(new Error('密码由6-20位数字、字母、下划线组成'));
        }

    }, 0);
}
//校验用户账号
//规则:6-15为数字字母的组合，不包含特殊符号(可以是纯数字,可以是纯字母,可以是数字加字母)
// 这个规则也是可以的，跟下面一样的效果  /^(?![0-9]+$)(?![a-zA-Z]+$)[0-9A-Za-z]{6,20}$/
export function testAccount(rule, value, callback) {
    if(value!=0){
        if (!value) {
            return callback(new Error('输入不可以为空'));
        }
    }
    setTimeout(() => {
        let newValue= value.replace(/\s*/g,"");
        const re = /^[0-9A-Za-z]+$/;  //这是校验不包含特殊符号
        const testIsContainSpec = re.test(newValue);
        if (!testIsContainSpec) {
            callback(new Error('请输入6-15位字母或数字'));
        } else if(newValue.length < 6 || newValue.length>15){
			callback(new Error('请输入6-15位字母或数字'));
        }else {
			callback();
		}

    }, 0);
}
//校验用户姓名
//规则:2-12为汉字数字字母的组合，不包含特殊符号(可以是纯数字,可以是纯字母,可以是数字加字母)
// 这个规则也是可以的，跟下面一样的效果  /^(?![0-9]+$)(?![a-zA-Z]+$)[0-9A-Za-z]{6,20}$/
export function testAccountName(rule, value, callback) {
    if(value!=0){
        if (!value) {
            return callback(new Error('输入不可以为空'));
        }
    }
    setTimeout(() => {
        let newValue= value.replace(/\s*/g,"");
        const re = /^[\u4e00-\u9fa5a-zA-Z0-9]+$/;  //这是校验不包含特殊符号
        const testIsContainSpec = re.test(newValue);
        if (!testIsContainSpec) {
            callback(new Error('请输入中文，字母或数字'));
        } else if(newValue.length < 2 || newValue.length>20){
			callback(new Error('长度为2-20位'));
        }else {
			callback();
		}

    }, 0);
}
//字典姓名
//规则:1-10为汉字数字字母的组合，不包含特殊符号(可以是纯数字,可以是纯字母,可以是数字加字母)
export function testDictName(rule, value, callback) {
    if(value!=0){
        if (!value) {
            return callback(new Error('输入不可以为空'));
        }
    }
    setTimeout(() => {
        let newValue= value.replace(/\s*/g,"");
        const re = /^[\u4e00-\u9fa5a-zA-Z0-9]+$/;  //这是校验不包含特殊符号
        const testIsContainSpec = re.test(newValue);
        if (!testIsContainSpec) {
            callback(new Error('请输入中文，字母或数字'));
        } else if(newValue.length < 1 || newValue.length>10){
			callback(new Error('长度为1-10位'));
        }else {
			callback();
		}

    }, 0);
}
//商品名称
//规则:2-30为汉字数字字母的组合，不包含特殊符号(可以是纯数字,可以是纯字母,可以是数字加字母)
export function testGoodsName(rule, value, callback) {
    if(value!=0){
        if (!value) {
            return callback(new Error('输入不可以为空'));
        }
    }
    setTimeout(() => {
		
        // let newValue= value.replace(/\s*/g,"");
		let empty=/^\S.*\S$/
        const re = /^[\u4e00-\u9fa5a-zA-Z0-9` ~!@#^&*()_\-+=<>:"{}|,;'·~！@#……&*（）—\-+={}|《》？\/：“”【】、；‘'，。.]+$/;  //这是校验不包含特殊符号
        const testIsContainSpec = re.test(value);
        const testEmpty = empty.test(value);
        if(value.length < 2 || value.length>50){
        	callback(new Error('长度为2-50位'));
        }else if (!testEmpty) {
            callback(new Error('不能以空格开始或结束'));
        }else if (!testIsContainSpec) {
            callback(new Error('不能输入特殊字符'));
        }else {
			callback();
		}

    }, 0);
}
//校验相册名称
//规则:1-16为汉字数字字母下划线的组合，(可以是纯数字,可以是纯字母,可以是数字加字母)
export function testPicNames(rule, value, callback) {
    if(value!=0){
        if (!value) {
            return callback(new Error('输入不可以为空'));
        }
    }
    setTimeout(() => {
        let newValue= value.replace(/\s*/g,"");
        const re = /^[\u4e00-\u9fa5a-zA-Z0-9—_]+$/;  //这是校验不包含特殊符号
        const testIsContainSpec = re.test(newValue);
        if (!testIsContainSpec) {
            callback(new Error('请输入中文，字母，数字或下划线'));
        } else if(newValue.length < 1 || newValue.length>16){
			callback(new Error('名称长度为1-16位'));
        }else {
			callback();
		}
    }, 0);
}
//规格属性名称
//规则:1-8为汉字数字字母下划线的组合，(可以是纯数字,可以是纯字母,可以是数字加字母)
export function testSpecName(rule, value, callback) {
    if(value!=0){
        if (!value) {
            return callback(new Error('输入不可以为空'));
        }
    }
    setTimeout(() => {
        let newValue= value.replace(/\s*/g,"");
        const re = /^[\u4e00-\u9fa5a-zA-Z0-9—_]+$/;  //这是校验不包含特殊符号
        const testIsContainSpec = re.test(newValue);
        if (!testIsContainSpec) {
            callback(new Error('请输入中文，字母，数字或下划线'));
        } else if(newValue.length < 1 || newValue.length>8){
			callback(new Error('名称长度为1-8位'));
        }else {
			callback();
		}
    }, 0);
}
//规格值
//规则:1-10为汉字数字字母 + / - ：的组合
export function testSpeValue(rule, value, callback) {
    if(value!=0){
        if (!value) {
            return callback(new Error('输入不可以为空'));
        }
    }
    setTimeout(() => {
        // let newValue= value.replace(/\s*/g,"");
		let empty=/^\S.*\S$/
        const re = /^[\u4e00-\u9fa5a-zA-Z0-9 *()_\-+=<>:"{}|,;'·&*（）—\-+={}|《》\/：“”【】、；‘'，。.]+$/;  //这是校验不包含特殊符号
        const testIsContainSpec = re.test(value);
		const testEmpty = empty.test(value);
		if(value.length < 1 || value.length>30){
			callback(new Error('规格值长度为1-30位'));
		}else if (!testEmpty&&value.length>1) {
            callback(new Error('不能以空格开始或结束'));
        }else if (!testEmpty&&value==' ') {
            callback(new Error('不能以空格开始或结束'));
        }else if (!testIsContainSpec) {
            callback(new Error('请输入有效规格值'));
        } else {
			callback();
		}
    }, 0);
}
//编码非汉字
export function testCode(rule, value, callback) {
    if (value) {
        if (/[\u4E00-\u9FA5]/g.test(value)) {
            callback(new Error('不能输入汉字!'));
        } else {
            callback();
        }
    }
    callback();
}

//校验是否是大于等于0的整数
export function testIsInteger(rule, value, callback){
    let re = /^[0-9]*[1-9][0-9]*$/; //是否是大于或者等于0的整数
    if(!re.test(value)){
        callback(new Error('需输入大于0的整数'));
    } else {
        callback();
    }
    callback();
}

//校验姓名输入
export function isCorrectName(rule, value, callback){
    let re = /^[\u4E00-\u9FA5]{2,4}$/;
    if (1 < value.length && value.length < 5) {
        if (!re.test(value)) {
            callback(new Error('姓名格式输入错误'));
        } else {
            callback();
        }
    } else {
        callback(new Error('请输入两位到四位字符'));
    }
}
//校验数字和字母的组合
export function checkBuyerNo(rule, value, callback){
    if (1 < value.length && value.length < 20) {
        let reg = new RegExp(/^[a-zA-Z0-9]{1,20}$/);
        if (!reg.test(value)) {
            callback(new Error('请输入数字和字母的组合'));
        } else {
            callback();
        }
    } else {
        callback(new Error('请输入20以内字符'));
    }
}

//转换输入的AppId,公钥，私钥里面的+号，以确保把+号正确存储(其他方法如果需要输入+号，并且正确存储，正确显示，也可以调用此方法)
export function convertAddCode(value, callback){
    let newValue = "";
    let tempArray = [];
    for(let i =0;i<value.length;i++){
        tempArray[i] = value[i].replace("+","%2B");
    }
    newValue = tempArray.join(" ");
    newValue = newValue.replace(/\s*/g,"");
    callback(newValue);
}
//校验是否有空格
 export function validateSpace(rule,value,callback) {
     if(!value){
         return callback(new Error('请输入内容'))
     }
     setTimeout(() => {
         const re = /^[^\s]*$/;
         const rsCheck = re.test(value);
         if (!rsCheck) {
             callback(new Error('填写字段不能含空格'));
         }else {
             callback();
         }
     }, 0);
 }

 /* 正整数*/
 export function validatNum(rule,value,callback) {
     if(!value){
         return callback(new Error('请输入内容'))
     }

     const reg = /^\+?[1-9][0-9]*$/
     const rsCheck = reg.test(value);
     if (!rsCheck) {
         callback(new Error('请输入正整数'));
     }else {
         callback();
     }
 }